﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using SchemasLib;
using docTissV2.Enumeradores;
using System.IO;
using DocumentFormat.OpenXml.Packaging;
using System.Xml;
using docTissV2.Classes.TreeNodeContents;
using System.Xml.Serialization;
using AcessaDados = AcessaDadosBD;
using AcessaDadosBD.Repositorios;

namespace docTissV2.Classes
{
    public class MensagemTISS
    {
        #region Cabecalho

        private static cabecalhoTransacao GeraCabecalho(ConteudoNoOperadora conteudoNoOperadora, AcessaDados.TipoTransacao tipoTransacao)
        {
            TransacaoRepository repositorioTransacao = new TransacaoRepository(AddinUtils.Command);
            
            AcessaDados.Transacao transacao = new AcessaDados.Transacao()
            {
                DataTransacao = DateTime.Now,
                TipoTransacao = tipoTransacao,
                IDOperadoraPrestador = conteudoNoOperadora.IDOperadoraPrestador
            };

            //Cadastra Transacao no BD
            try
            {
                transacao.SequencialTransacao = repositorioTransacao.Insert(transacao);
            }
            catch (Exception e)
            {
                throw new Exception("Erro ao gravar transação no BD: " + e.Message);
            }

            try
            {
                cabecalhoTransacao cabecalho = new cabecalhoTransacao();

                //Identificacao da transacao
                cabecalho.identificacaoTransacao = new cabecalhoTransacaoIdentificacaoTransacao();
                cabecalho.identificacaoTransacao.tipoTransacao = AddinUtils.ConverteAcessaDadosTipoTransacaoParaST_TipoTransacao(tipoTransacao);

                cabecalho.identificacaoTransacao.sequencialTransacao = transacao.SequencialTransacao.ToString();
                cabecalho.identificacaoTransacao.dataRegistroTransacao = transacao.DataTransacao.Date;
                cabecalho.identificacaoTransacao.horaRegistroTransacao = transacao.DataTransacao;

                // origem
                ct_identificacaoPrestadorExecutante origem = new ct_identificacaoPrestadorExecutante();
                if (conteudoNoOperadora.Identificacao == IdentificacaoPrestadorNaOperadora.CodigoPrestadorNaOperadora)
                    origem.ItemElementName = ItemChoiceType.codigoPrestadorNaOperadora;
                else if (conteudoNoOperadora.Identificacao == IdentificacaoPrestadorNaOperadora.CPF)
                    origem.ItemElementName = ItemChoiceType.CPF;
                else if (conteudoNoOperadora.Identificacao == IdentificacaoPrestadorNaOperadora.CNPJ)
                    origem.ItemElementName = ItemChoiceType.CNPJ;

                origem.Item = conteudoNoOperadora.CodigoNaOperadora;

                if (origem.Item != null)
                {
                    cabecalho.origem = new cabecalhoTransacaoOrigem();
                    cabecalho.origem.ItemElementName = ItemChoiceType1.codigoPrestadorNaOperadora;
                    cabecalho.origem.Item = origem;
                    // destino
                    cabecalho.destino = new cabecalhoTransacaoDestino();
                    cabecalho.destino.ItemElementName = ItemChoiceType2.registroANS;
                    cabecalho.destino.Item = conteudoNoOperadora.RegistroANS;
                    // versão padrão
                    cabecalho.versaoPadrao = st_versao.Item20203;

                    //Identificacao Software Gerador
                    cabecalho.identificacaoSoftwareGerador = new ct_identificacaoSoftwareGerador();
                    cabecalho.identificacaoSoftwareGerador.fabricanteAplicativo = "Laboratório de Tecnologia da Informação Aplicada - Ltia";
                    cabecalho.identificacaoSoftwareGerador.nomeAplicativo = "docTiss";
                    cabecalho.identificacaoSoftwareGerador.versaoAplicativo = "versão 2.0";

                    return cabecalho;
                }
                else return null;
            }
            catch (Exception e)
            {
                throw new Exception("Erro ao gerar cabeçalho da MensagemTISS: " + e.Message);
            }
        }

        #endregion

        #region Mensagem

        public static void CriaMensagemTISSGuiaFaturamento(ConteudoNoTipoGuia conteudoNoTipoGuia, string numeroLote, List<string[]> guiasPath, string xmlPath)
        {
            try
            {
                mensagemTISS msg = new mensagemTISS();

                msg.cabecalho = GeraCabecalho(conteudoNoTipoGuia.NoOperadora, AcessaDados.TipoTransacao.ENVIO_LOTE_GUIAS);

                mensagemTISSPrestadorParaOperadora corpo = new mensagemTISSPrestadorParaOperadora();

                corpo.Item = GeraLoteGuias(numeroLote, conteudoNoTipoGuia.TipoGuia, guiasPath);

                msg.Item = corpo;

                msg.epilogo = new mensagemTISSEpilogo();

                msg.epilogo.hash = GeraHash(msg);

                GeraXMLMensagemTISS(xmlPath, msg);
            }
            catch (Exception e)
            {
                
                throw new Exception("Erro ao criar MensagemTISS: " + e.Message);
            }
            
        }

        public static void CriaMensagemTISSGuiaSolicitacao()
        {
            try
            {
                mensagemTISS msg = new mensagemTISS();

                //msg.cabecalho = GeraCabecalho();

                //msg.Item = GeraLoteGuias(numeroLote, tipoGuia, guiasPath);

                //msg.epilogo.hash = GeraHash(msg);

                //GeraXMLMensagemTISS(xmlPath, msg);
            }
            catch (Exception e)
            {

                throw new Exception("Erro ao criar MensagemTISS: " + e.Message);
            }

        }

        #region LoteGuias
        /// <summary>
        /// Cria objeto ws_loteGuias a ser enviado para o webservice da operadora.
        /// A lista guiasPath deve conter um array de string para cada guia:
        /// A posição [0] do array deve estar o endereço da guia;
        /// As demais posições deve conter o endereço das guias de outras despesas, caso existam.
        /// </summary>
        /// <param name="codPrestadorOrigem">código do Prestador</param>
        /// <param name="regANSDestino">registro na ANS da operadora</param>
        /// <param name="numeroLote">número do lote a ser enviado</param>
        /// <param name="guiasPath">endereço (Path) de cada guia</param>
        /// <returns></returns>
        private static ct_loteGuias GeraLoteGuias(string numeroLote, TipoGuia tipoGuia, List<string[]> guiasPath)
        {
            ct_loteGuias loteGuias = new ct_loteGuias();

            try
            {
                loteGuias.numeroLote = numeroLote;

                loteGuias.guias = new ct_loteGuiasGuias();

                object itemLoteGuias = null;

                if (tipoGuia <= TipoGuia.Odontologia)
                {
                    itemLoteGuias = new ct_guiasGuiaFaturamento();
                    ((ct_guiasGuiaFaturamento)itemLoteGuias).Items = new Object[guiasPath.Count];
                }
                else
                {
                    itemLoteGuias = new ct_guiasGuiaRevisaoGlosa();
                    ((ct_guiasGuiaRevisaoGlosa)itemLoteGuias).Items = new Object[guiasPath.Count];
                }

                Object[] itemGuias = new Object[guiasPath.Count];

                int guiaIndex = 0;

                foreach (string[] guiaArray in guiasPath)
                {
                    try
                    {
                        object guia = ExtraiGuiaCustomXML(guiaArray, tipoGuia);

                        if (guia != null)
                        {
                            itemGuias[guiaIndex] = guia;
                            guiaIndex++;
                        }
                        else
                        {
                            itemGuias = new object[0];
                            break;
                        }
                    }
                    catch (Exception e)
                    {
                        throw new Exception("Erro ao extrair XML da guia: " + e.Message);
                    }
                }

                if (itemGuias != null)
                {
                    if (tipoGuia <= TipoGuia.Odontologia)
                        ((ct_guiasGuiaFaturamento)itemLoteGuias).Items = itemGuias;
                    else
                        ((ct_guiasGuiaRevisaoGlosa)itemLoteGuias).Items = itemGuias;
                }

                loteGuias.guias.Item = itemLoteGuias;

                return loteGuias;
            }
            catch (Exception ex)
            {
                throw new Exception("Erro ao gerar Lote de Guias: " + ex.Message);
            }
        }

        /// <summary>
        /// Extrai o objeto ct_guia do arquivo docx.
        /// guiaArray[0] = path da guia;
        /// guiaArray[i>0] = path guia outras despesas.
        /// </summary>
        /// <param name="guiaArray"></param>
        /// <returns></returns>
        private static object ExtraiGuiaCustomXML(string[] guiaArray, TipoGuia tipoGuia)
        {
            //Os parametros podem ser ExtraiGuiaCustomXML(TipoGuia tipoGuia, params string[] guiasPath),
            //assim é possível passar apenas uma string caso nao existam guias de outras despesas.
            string filePath = guiaArray[0];
            using (WordprocessingDocument wdoc = WordprocessingDocument.Open(filePath, false))
            {
                //Buscando o CustomXML referente a Guia
                foreach (CustomXmlPart cPart in wdoc.MainDocumentPart.CustomXmlParts)
                {
                    //Carrega a parte
                    XmlDocument xdoc = new XmlDocument();
                    xdoc.Load(cPart.GetStream());

                    //Encontrou?
                    if (xdoc.InnerXml.Contains("http://www.ans.gov.br/padroes/tiss/schemas"))
                    {
                        try
                        {
                            switch (tipoGuia)
                            {
                                case TipoGuia.Consulta:
                                    return geraGuiaConsulta(xdoc);
                                case TipoGuia.SP_SADT:
                                    return geraGuiaSP_SADT(xdoc, guiaArray);
                                case TipoGuia.Resumo_Internação:
                                    return geraGuiaResumoInternacao(xdoc, guiaArray);
                                case TipoGuia.Honorário_Individual:
                                    return geraGuiaHonorarioIndividual(xdoc);
                                case TipoGuia.Odontologia:
                                    return geraGuiaOdontologia(xdoc);
                                case TipoGuia.Consulta_Reapresentação:
                                    return geraGuiaConsultaReapresentacao(xdoc);
                                case TipoGuia.SP_SADT_Reapresentação:
                                    return geraGuiaSP_SADTReapresentacao(xdoc, guiaArray);
                                case TipoGuia.Resumo_Internação_Reapresentação:
                                    return geraGuiaResumoInternacaoReapresentacao(xdoc, guiaArray);
                                case TipoGuia.Honorário_Individual_Reapresentação:
                                    return geraGuiaHonorarioIndividualReapresentacao(xdoc);
                                case TipoGuia.Odontologia_Reapresentação:
                                    return geraGuiaOdontologiaReapresentacao(xdoc);
                            }
                        }
                        catch (Exception ex)
                        {
                            throw new Exception("O lote não pode ser gerado:\nA guia '" + Path.GetFileName(filePath) + "' contém problemas de validação em sua estrutura.");
                        }
                    }
                }
            }
            return null;
        }

        private static object geraGuiaConsulta(XmlDocument xdoc)
        {
            if (xdoc.InnerXml.Contains("guiaConsulta"))
            {
                byte[] buffer = Encoding.GetEncoding("ISO-8859-1").GetBytes(XMLUtils.GetNormalizedXMLString(xdoc));
                Stream str = new MemoryStream(buffer);
                
                ct_guiaConsulta guiaConsulta = (ct_guiaConsulta)XMLUtils.Deserializa(str, typeof(ct_guiaConsulta), XMLUtils.ElementRootWithANSnamespace("guiaConsulta"));

                if (guiaConsulta.dadosContratado.enderecoContratado.complemento == null)
                    guiaConsulta.dadosContratado.enderecoContratado.complemento = string.Empty;
                
                return guiaConsulta;
            }
            return null;
        }

        private static object geraGuiaSP_SADT(XmlDocument xdoc, string[] guiaArray)
        {
            if (xdoc.InnerXml.Contains("guiaSP_SADT"))
            {
                byte[] buffer = Encoding.GetEncoding("ISO-8859-1").GetBytes(XMLUtils.GetNormalizedXMLString(xdoc));
                Stream str = new MemoryStream(buffer);
                ct_guiaSP_SADT gspsadt = (ct_guiaSP_SADT)XMLUtils.Deserializa(str, typeof(ct_guiaSP_SADT), XMLUtils.ElementRootWithANSnamespace("guiaSP_SADT"));

                for (int i = 1; i < guiaArray.Length; i++)
                {
                    string OutrasDespesasPath = guiaArray[i];

                    using (WordprocessingDocument wdocOutrasDepesas = WordprocessingDocument.Open(OutrasDespesasPath, false))
                    {
                        //Buscando o CustomXML referente a Guia
                        foreach (CustomXmlPart cPartOutrasDepesas in wdocOutrasDepesas.MainDocumentPart.CustomXmlParts)
                        {
                            //Carrega a parte
                            XmlDocument xdocOutrasDepesas = new XmlDocument();
                            xdocOutrasDepesas.Load(cPartOutrasDepesas.GetStream());

                            //Encontrou?
                            if (xdocOutrasDepesas.InnerXml.Contains("outrasDespesas"))
                            {
                                byte[] bufferOutrasDepesas = Encoding.GetEncoding("ISO-8859-1").GetBytes(XMLUtils.GetNormalizedXMLString(xdocOutrasDepesas));
                                Stream strOutrasDepesas = new MemoryStream(bufferOutrasDepesas);

                                ct_outrasDespesas gOutrasDespesas = (ct_outrasDespesas)XMLUtils.Deserializa(strOutrasDepesas, typeof(ct_outrasDespesas), XMLUtils.ElementRootWithANSnamespace("outrasDespesas"));

                                gspsadt.outrasDespesas = gOutrasDespesas;
                            }
                        }
                    }
                }
                return (object)gspsadt;
            }
            return null;
        }

        private static object geraGuiaResumoInternacao(XmlDocument xdoc, string[] guiaArray)
        {
            if (xdoc.InnerXml.Contains("guiaResumoInternacao"))
            {
                byte[] buffer = Encoding.GetEncoding("ISO-8859-1").GetBytes(XMLUtils.GetNormalizedXMLString(xdoc));
                Stream str = new MemoryStream(buffer);

                ct_guiaResumoInternacao gResumoInternacao = (ct_guiaResumoInternacao)XMLUtils.Deserializa(str, typeof(ct_guiaResumoInternacao), XMLUtils.ElementRootWithANSnamespace("guiaResumoInternacao"));

                for (int i = 1; i < guiaArray.Length; i++)
                {
                    string OutrasDespesasPath = guiaArray[i];

                    using (WordprocessingDocument wdocOutrasDepesas = WordprocessingDocument.Open(OutrasDespesasPath, false))
                    {
                        //Buscando o CustomXML referente a Guia
                        foreach (CustomXmlPart cPartOutrasDepesas in wdocOutrasDepesas.MainDocumentPart.CustomXmlParts)
                        {
                            //Carrega a parte
                            XmlDocument xdocOutrasDepesas = new XmlDocument();
                            xdocOutrasDepesas.Load(cPartOutrasDepesas.GetStream());

                            //Encontrou?
                            if (xdocOutrasDepesas.InnerXml.Contains("outrasDespesas"))
                            {
                                //Retira os campos não obrigatórios que não foram preenchidos
                                //string normalizedXML = XMLUtils.GetNormalizedXMLString(xdoc);
                                byte[] bufferOutrasDepesas = Encoding.GetEncoding("ISO-8859-1").GetBytes(XMLUtils.GetNormalizedXMLString(xdocOutrasDepesas));
                                Stream strOutrasDepesas = new MemoryStream(bufferOutrasDepesas);
                                ct_outrasDespesas gOutrasDespesas = (ct_outrasDespesas)XMLUtils.Deserializa(strOutrasDepesas, typeof(ct_outrasDespesas), XMLUtils.ElementRootWithANSnamespace("outrasDespesas"));

                                gResumoInternacao.outrasDespesas = gOutrasDespesas;
                            }
                        }
                    }
                }

                return (object)gResumoInternacao;
            }
            return null;
        }

        private static object geraGuiaHonorarioIndividual(XmlDocument xdoc)
        {
            if (xdoc.InnerXml.Contains("guiaHonorarioIndividual"))
            {
                byte[] buffer = Encoding.GetEncoding("ISO-8859-1").GetBytes(XMLUtils.GetNormalizedXMLString(xdoc));
                Stream str = new MemoryStream(buffer);

                return XMLUtils.Deserializa(str, typeof(ct_guiaHonorarioIndividual), XMLUtils.ElementRootWithANSnamespace("guiaHonorarioIndividual"));
            }
            return null;
        }

        private static object geraGuiaConsultaReapresentacao(XmlDocument xdoc)
        {
            if (xdoc.InnerXml.Contains("guiaConsultaReapresentacao"))
            {
                byte[] buffer = Encoding.GetEncoding("ISO-8859-1").GetBytes(XMLUtils.GetNormalizedXMLString(xdoc));
                Stream str = new MemoryStream(buffer);

                return XMLUtils.Deserializa(str, typeof(ct_guiaConsultaReapresentacao), XMLUtils.ElementRootWithANSnamespace("guiaConsultaReapresentacao"));
            }
            return null;
        }

        private static object geraGuiaSP_SADTReapresentacao(XmlDocument xdoc, string[] guiaArray)
        {
            if (xdoc.InnerXml.Contains("guiaSP_SADTReapresentacao"))
            {
                byte[] buffer = Encoding.GetEncoding("ISO-8859-1").GetBytes(XMLUtils.GetNormalizedXMLString(xdoc));
                Stream str = new MemoryStream(buffer);
                ct_guiaSP_SADTReapresentacao gspsadt = (ct_guiaSP_SADTReapresentacao)XMLUtils.Deserializa(str, typeof(ct_guiaSP_SADT), XMLUtils.ElementRootWithANSnamespace("guiaSP_SADTReapresentacao"));

                for (int i = 1; i < guiaArray.Length; i++)
                {
                    string OutrasDespesasPath = guiaArray[i];

                    using (WordprocessingDocument wdocOutrasDepesas = WordprocessingDocument.Open(OutrasDespesasPath, false))
                    {
                        //Buscando o CustomXML referente a Guia
                        foreach (CustomXmlPart cPartOutrasDepesas in wdocOutrasDepesas.MainDocumentPart.CustomXmlParts)
                        {
                            //Carrega a parte
                            XmlDocument xdocOutrasDepesas = new XmlDocument();
                            xdocOutrasDepesas.Load(cPartOutrasDepesas.GetStream());

                            //Encontrou?
                            if (xdocOutrasDepesas.InnerXml.Contains("guiaOutrasDespesasRevisao"))
                            {
                                byte[] bufferOutrasDepesas = Encoding.GetEncoding("ISO-8859-1").GetBytes(xdocOutrasDepesas.InnerXml);
                                Stream strOutrasDepesas = new MemoryStream(bufferOutrasDepesas);
                                ct_outrasDespesasRevisao gOutrasDespesas = (ct_outrasDespesasRevisao)XMLUtils.Deserializa(str, typeof(ct_outrasDespesasRevisao), XMLUtils.ElementRootWithANSnamespace("guiaOutrasDespesasRevisao"));

                                gspsadt.outrasDespesas = gOutrasDespesas;
                            }
                        }
                    }
                }
                return (object)gspsadt;
            }
            return null;
        }

        private static object geraGuiaResumoInternacaoReapresentacao(XmlDocument xdoc, string[] guiaArray)
        {
            if (xdoc.InnerXml.Contains("guiaResumoInternacaoReapresentacao"))
            {
                byte[] buffer = Encoding.GetEncoding("ISO-8859-1").GetBytes(XMLUtils.GetNormalizedXMLString(xdoc));
                Stream str = new MemoryStream(buffer);

                ct_guiaResumoInternacaoReapresentacao gResumoInternacao = (ct_guiaResumoInternacaoReapresentacao)XMLUtils.Deserializa(str, typeof(ct_guiaResumoInternacaoReapresentacao), XMLUtils.ElementRootWithANSnamespace("guiaResumoInternacaoReapresentacao"));

                for (int i = 1; i < guiaArray.Length; i++)
                {
                    string OutrasDespesasPath = guiaArray[i];

                    using (WordprocessingDocument wdocOutrasDepesas = WordprocessingDocument.Open(OutrasDespesasPath, false))
                    {
                        //Buscando o CustomXML referente a Guia
                        foreach (CustomXmlPart cPartOutrasDepesas in wdocOutrasDepesas.MainDocumentPart.CustomXmlParts)
                        {
                            //Carrega a parte
                            XmlDocument xdocOutrasDepesas = new XmlDocument();
                            xdocOutrasDepesas.Load(cPartOutrasDepesas.GetStream());

                            //Encontrou?
                            if (xdocOutrasDepesas.InnerXml.Contains("guiaOutrasDespesasRevisao"))
                            {
                                //Retira os campos não obrigatórios que não foram preenchidos
                                //string normalizedXML = XMLUtils.GetNormalizedXMLString(xdoc);
                                byte[] bufferOutrasDepesas = Encoding.GetEncoding("ISO-8859-1").GetBytes(xdocOutrasDepesas.InnerXml);
                                Stream strOutrasDepesas = new MemoryStream(bufferOutrasDepesas);
                                ct_outrasDespesasRevisao gOutrasDespesas = (ct_outrasDespesasRevisao)XMLUtils.Deserializa(str, typeof(ct_outrasDespesasRevisao), XMLUtils.ElementRootWithANSnamespace("guiaOutrasDespesasRevisao"));

                                gResumoInternacao.outrasDespesas = gOutrasDespesas;
                            }
                        }
                    }
                }

                return (object)gResumoInternacao;
            }
            return null;
        }

        private static object geraGuiaHonorarioIndividualReapresentacao(XmlDocument xdoc)
        {
            if (xdoc.InnerXml.Contains("guiaHonorarioIndividualReapresentacao"))
            {
                byte[] buffer = Encoding.GetEncoding("ISO-8859-1").GetBytes(XMLUtils.GetNormalizedXMLString(xdoc));
                Stream str = new MemoryStream(buffer);

                return XMLUtils.Deserializa(str, typeof(ct_guiaHonorarioIndividualReapresentacao), XMLUtils.ElementRootWithANSnamespace("guiaHonorarioIndividualReapresentacao"));
            }
            return null;
        }

        private static object geraGuiaOdontologia(XmlDocument xdoc)
        {
            if (xdoc.InnerXml.Contains("guiaOdontologia"))
            {
                byte[] buffer = Encoding.GetEncoding("ISO-8859-1").GetBytes(XMLUtils.GetNormalizedXMLString(xdoc));
                Stream str = new MemoryStream(buffer);

                return XMLUtils.Deserializa(str, typeof(ct_guiaOdontologia), XMLUtils.ElementRootWithANSnamespace("guiaOdontologia"));
            }
            return null;
        }

        private static object geraGuiaOdontologiaReapresentacao(XmlDocument xdoc)
        {
            if (xdoc.InnerXml.Contains("guiaOdontologiaReapresentacao"))
            {
                byte[] buffer = Encoding.GetEncoding("ISO-8859-1").GetBytes(XMLUtils.GetNormalizedXMLString(xdoc));
                Stream str = new MemoryStream(buffer);

                return XMLUtils.Deserializa(str, typeof(ct_guiaTratamentoOdontologicoReapresentacao), XMLUtils.ElementRootWithANSnamespace("guiaOdontologiaReapresentacao"));
            }
            return null;
        }

        #endregion

        #endregion

        #region Epilogo

        private static string GeraHash(mensagemTISS msgTISS)
        {
            try
            {
                Stream streamMensagem = XMLUtils.Serializa(msgTISS, null);
                streamMensagem.Position = 0;

                //Fim da Mensagem: HASH
                return AddinUtils.CalculateMD5Hash(streamMensagem);
            }
            catch (Exception e)
            {
                throw new Exception("Erro ao gerar HashMD5: " + e.Message);
            }
        }

        private static void GeraXMLMensagemTISS(string selectedPath, mensagemTISS msgTISS)
        {
            try
            {
                ////<sequencial de mensagem TISS>_<hash MD5 da mensagem>.xml
                XmlTextWriter writer = new XmlTextWriter(selectedPath + "\\" + msgTISS.cabecalho.identificacaoTransacao.sequencialTransacao.PadLeft(12, '0') +
                    "_" + msgTISS.epilogo.hash + ".xml", System.Text.Encoding.GetEncoding("ISO-8859-1"));
                writer.WriteStartDocument();
                writer.WriteComment("XML Gerado pelo docTISS versão 2.0.1 - Data: " + DateTime.Now.ToString("dd/MM/yyyy HH:mm"));

                XmlSerializer xsMensagem = new XmlSerializer(typeof(mensagemTISS), XMLUtils.ElementRootWithANSnamespace("mensagemTISS"));
                xsMensagem.Serialize(writer, msgTISS, XMLUtils.ANSnamespace());
                writer.Close();
            }
            catch (Exception e)
            {
                throw new Exception("Erro ao gravar arquivo no disco: " + e.Message);
            }
        }

        #endregion
    }
}
